package co.yixiang.common.aspect;


import co.yixiang.common.annotation.Sensitive;
import co.yixiang.common.vo.ResultMessage;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;

import java.lang.reflect.Field;
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

// @Aspect
// @Configuration
public class ParamProcessAspect {
//    public static final String ACCESS_EXECUTION = "execution(* co.yixiang.modules.mp..*(..))";
//    @Pointcut("@annotation(co.yixiang.common.annotation.Prefixion) ")
//    public void pointCut() {
//    }
//
//    @Around(ACCESS_EXECUTION)
//    public Object paramProcess(ProceedingJoinPoint joinPoint) throws Throwable {
//        Object obj =  joinPoint.getSignature();
//        if (obj == null || isPrimitive(obj.getClass()) ) {
//            return obj;
//        }
//        desentData(obj);
//        return obj;
//    }
    /**
     * 脱敏数据
     *
     * @param obj
     * @return void
     */
    public static void desentData(Object obj) throws IllegalAccessException {
        if (null == obj) {
            return;
        }

        //如果是原始类型，则忽略处理
        if (obj.getClass().isPrimitive()) {
            return;
        }
        // 是否是接口
        if (obj.getClass().isInterface()) {
            return;
        }
        System.out.println(obj);
        System.out.println(obj.getClass());
        Object data = null;
        Class<?> clazz = null;
        //如果是通用的分页响应对象，则对该对象内部的List<T>进行脱敏
        if (obj.getClass().equals(ResultMessage.class)) {
            data = ((ResultMessage) obj).getResult();//这里是自定义返回对象
            clazz = data.getClass();
            if (null == clazz) {
                return;
            }
        }

        // 获取所有属性
        Field[] fields = clazz.getDeclaredFields();
        while (null != clazz.getSuperclass() && !Object.class.equals(clazz.getSuperclass())) {
            fields = (Field[]) ArrayUtils.addAll(fields, clazz.getSuperclass().getDeclaredFields());
            clazz = clazz.getSuperclass();
        }

        if (null == fields && fields.length == 0) {
            return;
        }

        for (Field field : fields) {
            field.setAccessible(true);
            if (null == field) {
                return;
            }
            Object value = field.get(data);
            if (null != value) {
                Class<?> type = value.getClass();
                // 1.处理子属性，包括集合中的
                if (type.isArray()) {
                    int len = Array.getLength(value);
                    for (int i = 0; i < len; i++) {
                        Object arrayObject = Array.get(value, i);
                        desentData(arrayObject);
                    }
                } else if (value instanceof Collection<?>) {
                    Collection<?> c = (Collection<?>) value;
                    Iterator<?> it = c.iterator();
                    while (it.hasNext()) {
                        Object collectionObj = it.next();
                        desentData(collectionObj);
                    }
                } else if (value instanceof Map<?, ?>) {
                    Map<?, ?> m = (Map<?, ?>) value;
                    Set<?> set = m.entrySet();
                    for (Object o : set) {
                        Map.Entry<?, ?> entry = (Map.Entry<?, ?>) o;
                        Object mapVal = entry.getValue();
                        desentData(mapVal);
                    }
                } else if (!type.isPrimitive()
                        && !StringUtils.startsWith(type.getPackage().getName(), "javax.")
                        && !StringUtils.startsWith(type.getPackage().getName(), "java.")
                        && !StringUtils.startsWith(field.getType().getName(), "javax.")
                        && !StringUtils.startsWith(field.getName(), "java.")) {
                    desentData(type);
                }
            }

            // 2. 处理自身的属性
            Sensitive annotation = field.getDeclaredAnnotation(Sensitive.class);
            if (field.getType().equals(String.class) && null != annotation) {
                String valueStr = (String) field.get(data);
                if (StringUtils.isNotBlank(valueStr)) {
                    // 处理 前缀拼接
                    field.set(data, chineseName(valueStr));
                }
            }
        }

    }
    /**
     * [中文姓名] 只显示第一个汉字，其他隐藏为2个星号<例子：李**>
     *
     * @param fullName 中文姓名
     * @return 中文姓名
     */
    private static String chineseName(String fullName) {
        if (StringUtils.isBlank(fullName)) {
            return "";
        }
        return "http://127.0.0.1:8000" + fullName;
    }
    /**
     * 基本数据类型和String类型判断
     */
    public static boolean isPrimitive(Class<?> clz) {
        try {
            if (String.class.isAssignableFrom(clz) || clz.isPrimitive()) {
                return true;
            } else {
                return ((Class) clz.getField("TYPE").get(null)).isPrimitive();
            }
        } catch (Exception e) {
            return false;
        }
    }

}
